//------------------------------------------------------------------------
//
//	CCGameBox is a game development library for iPhone and iPod Touch.
//
//	Licensed under the BSD license, see LICENSE in root for details.
// 
//	Copyright (c) 2009 James Hui (a.k.a. Dr.Watson)
// 
//	For latest updates, please visit http://www.cocoachina.com
//
//------------------------------------------------------------------------

#ifndef _CCRENDEREBOX_H_
#define _CCRENDEREBOX_H_

#ifdef WIN32
#include <GLES/gl.h>
#else
#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/ES1/glext.h>
#endif

#include "CCTypes.h"

#define MAX_VERTEX_BUFFER		2048

class CCTexture;
class CCImage;


//////////////////////////////////////////////////////////////////////////
/// Renderer.
/// 
//////////////////////////////////////////////////////////////////////////
class CCRenderBox
{
protected:
	
	CCRenderBox();
	~CCRenderBox();
	void Init();
	void ShutDown();
	
public:
	
	
	//////////////////////////////////////////////////////////////////////////
	/// Get the singleton instance.
	///
	//////////////////////////////////////////////////////////////////////////
	static CCRenderBox* GetInstance();

	//////////////////////////////////////////////////////////////////////////
	/// Destroy instance.
	//////////////////////////////////////////////////////////////////////////
	static void Destroy();
	
	//////////////////////////////////////////////////////////////////////////
	/// Restrict rendering to a rectangular area.
	/// 
	/// @param x - X position of the clipping area
	/// @param y - Y position of the clipping area.
	/// @param width - Width of the clipping area.
	/// @param height - Height of the clipping area.
	/// 
	//////////////////////////////////////////////////////////////////////////
	void SetClip(int x, int y, int width, int height);
	
	//////////////////////////////////////////////////////////////////////////
	/// Remove clipping region.
	///
	//////////////////////////////////////////////////////////////////////////
	void NoClip();

	//////////////////////////////////////////////////////////////////////////
	/// Start rendering in 3D mode.
	///
	//////////////////////////////////////////////////////////////////////////
	void SwitchTo3D();
	
	//////////////////////////////////////////////////////////////////////////
	/// Start rendering in 2D mode.
	///
	//////////////////////////////////////////////////////////////////////////
	void SwitchTo2D();

	//////////////////////////////////////////////////////////////////////////
	/// Fill a rectangular area with the current colour.
	///
	/// @param x - Starting x position.
	/// @param y - Starting y position.
	/// @param width - Width of the rectangle.
	/// @param height - Height of the rectangle.
	///
	//////////////////////////////////////////////////////////////////////////
	void FillRect(int x, int y, int width, int height);
	
	//////////////////////////////////////////////////////////////////////////
	/// Draw circle.
	/// 
	/// @param x - X positions of center of the circle.
	/// @param y - Y positions of center of the circle.
	/// @param radius - Radius of circle.
	///
	//////////////////////////////////////////////////////////////////////////
	void DrawCircle(float x, float y, float radius);
	
	//////////////////////////////////////////////////////////////////////////
	/// Draw polygon.
	/// 
	/// @param x - Array of X positions.
	/// @param y - Array of Y positions.
	/// @param count - Side count of the polygon.
	///
	//////////////////////////////////////////////////////////////////////////
	void DrawPolygon(float* x, float* y, int count);

	//////////////////////////////////////////////////////////////////////////
	/// Bind texture for the rendering
	///
	//////////////////////////////////////////////////////////////////////////
	void BindTexture(CCTexture *texture);
	
	//////////////////////////////////////////////////////////////////////////
	/// Load a texture from file.
	/// 
	/// @param filename - Name of file.
	/// @param directory - Optional folder name.
	/// 
	//////////////////////////////////////////////////////////////////////////
	CCTexture* LoadTexture(const char *filename, const char *directory=NULL);
	
	//////////////////////////////////////////////////////////////////////////
	/// Create texture from memory on the fly.
	/// 
	/// @param width - Width of texture.
	/// @param height - Height of texture.
	/// 
	//////////////////////////////////////////////////////////////////////////
	CCTexture* CreateTexture(int width, int height);
	
	//////////////////////////////////////////////////////////////////////////
	///	Flush all the vertices in vertex buffer to the screen.
	/// 
	//////////////////////////////////////////////////////////////////////////
	void Flush();
	
	//////////////////////////////////////////////////////////////////////////
	/// Render a textured quad with rotation and scaling.
	///
	/// @param quad - Quad with texture info.
	/// @param xo - x position.
	/// @param yo - y position.
	/// @param angle - Rotation (radian).
	/// @param xScale - Horizontal rendering scale.
	/// @param yScale - Vertical rendering scale.
	///
	//////////////////////////////////////////////////////////////////////////
	void RenderImage(CCImage* quad, float xo, float yo, float angle=0.0f, float xScale=1.0f, float yScale=1.0f);
	
	//////////////////////////////////////////////////////////////////////////
	/// Render a textured quad with new texture mapping information.
	///
	/// @param quad - Quad with texturing information.
	/// @param points - Array of vertices with new texture mapping information.
	///
	//////////////////////////////////////////////////////////////////////////
	void RenderImage(CCImage* quad, Vertex2D* points);
	
	//////////////////////////////////////////////////////////////////////////
	/// Set current rendering colour.
	///
	/// @param r - Red component.
	/// @param g - Green component.
	/// @param b - Blue component.
	/// @param a - Alpha component.
	/// 
	//////////////////////////////////////////////////////////////////////////
	void SetColor(float r, float g, float b, float a);
	
	//////////////////////////////////////////////////////////////////////////
	/// Turning on/off addictive drawing.
	///
	/// @param flag - True to turn on, otherwise off.
	/// 
	//////////////////////////////////////////////////////////////////////////
	void EnableAddictiveDraw(bool flag);
	
	//////////////////////////////////////////////////////////////////////////
	/// Turning of/off bilinear texture filtering.
	///
	/// @param flag - True to turn on, otherwise off.
	///
	//////////////////////////////////////////////////////////////////////////
	void EnableLinearFiltering(bool flag);
	
	//////////////////////////////////////////////////////////////////////////
	/// Turning on/off colour buffer.
	///
	/// @param flag - True to turn on, otherwise off.
	///
	//////////////////////////////////////////////////////////////////////////
	void EnableColorPointer(bool flag);
	
	//////////////////////////////////////////////////////////////////////////
	/// Start of rendering.
	///
	//////////////////////////////////////////////////////////////////////////
	void RenderBegin();
	
	//////////////////////////////////////////////////////////////////////////
	/// End of rendering.
	///
	//////////////////////////////////////////////////////////////////////////
	void RenderEnd();
	
	void RenderBlurImage(CCImage* quad,int times,float inc);
	
		
private:
		
	static CCRenderBox* mInstance;
		
	GLuint mCurrentTex;
	bool mLinearFiltering;
	bool mUseColorPointer;
	
	float mScreenWidth;
	float mScreenHeight;
	
};


#endif
